from typing import Annotated, Optional, List, Dict, Union, Tuple
from fastapi import Depends, FastAPI, HTTPException, Query
from sqlmodel import Field, Session, SQLModel, create_engine, select, Relationship, Column,JSON
from sqlalchemy import JSON
from datetime import datetime
from .systems import SystemOrg

"""量表推送

Keyword arguments:
ScalePushBase -- 量表推送基础模型
ScalePushCreate -- 新增量表推送模型
ScalePushUpdate -- 编辑量表推送模型
ScalePushRead -- 量表推送读取模型
ScalePush -- 量表推送模型（表）
Return: return_description
"""


class ScalePushBase(SQLModel):
    url: str = Field(max_length=8, nullable=False)  # 推送唯一链接（字母+数字）
    status: bool = Field(
        nullable=False, default=True
    )  # 推送状态（0：未推送，1：已推送）
    scale_detail_id: int = Field(
        nullable=False, foreign_key="scale_detail.id", ondelete="CASCADE"
    )  # 量表详情的id


class ScalePushCreate(ScalePushBase):
    pass


class ScalePushUpdate(ScalePushBase):
    id: int


class ScalePushRead(ScalePushBase):
    id: int

    create_id: int | None  # 创建人id
    creator: str | None  # 创建人名称
    createtime: datetime | None  # 创建时间


class RespJsonScalePush(SQLModel):
    code: int = Field(default=200)
    msg: str = Field(default="查询成功")
    data: ScalePushRead | None = {}


class ScalePush(ScalePushBase, table=True):
    __tablename__ = "scale_push"  # 表名
    __table_args__ = {"comment": "量表推送列表，存储量表推送列表信息"}

    id: int = Field(default=None, primary_key=True, index=True)

    create_id: int | None = Field(
        nullable=True, foreign_key="user_doctor.id", ondelete="CASCADE"
    )  # 创建人id
    createtime: datetime = Field(
        default_factory=datetime.now, nullable=False
    )  # 创建时间

    def __str__(self):
        return "ScalePush(url:{})".format(self.url)


"""量表答题记录

Keyword arguments:
ScaleAnswerRecordBase -- 量表答题记录基础模型
ScaleAnswerRecordCreate -- 新增量表答题记录模型
ScaleAnswerRecordUpdate -- 编辑量表答题记录模型
ScaleAnswerRecordRead -- 量表答题记录读取模型
ScaleAnswerRecord -- 量表答题记录模型（表）
Return: return_description
"""


class ScaleAnswerRecordBase(SQLModel):
    scale_push_id: int = Field(
        nullable=False, foreign_key="scale_push.id", ondelete="CASCADE"
    )  # 量表推送id
    scale_id: int = Field(
        nullable=False, foreign_key="scale.id", ondelete="CASCADE"
    )  # 量表id
    scale_detail_id: int = Field(
        nullable=False, foreign_key="scale_detail.id", ondelete="CASCADE"
    )
    # 开始答题的时间
    start_time: datetime = Field(default_factory=datetime.now, nullable=False)
    # 结束答题的时间
    end_time: datetime | None = Field(nullable=True)
    # 答题时长（秒）
    duration: int | None = Field(nullable=True)
    # 备注
    remark: str | None = Field(max_length=5000, nullable=True)
    # 答题状态（0：未完成，1：已完成， 2：已作废）
    status: int = Field(default=0, nullable=False)
    # 提交人的类型（0：游客，1：患者，2：医生，3：后台管理人员）
    submit_type: int | None = Field(default=None, nullable=True)
    # 提交人id
    submit_id: int | None = Field(nullable=True)


class ScaleAnswerRecordCreate(ScaleAnswerRecordBase):
    pass


class ScaleAnswerRecordUpdate(ScaleAnswerRecordBase):
    id: int


class ScaleAnswerRecordRead(ScaleAnswerRecordBase):
    id: int

    questions: List["ScaleAnswerDetailQuesRead"] | None = []


class ScaleAnswerRecord(ScaleAnswerRecordBase, table=True):
    __tablename__ = "scale_answer_record"  # 表名
    __table_args__ = {"comment": "量表答题记录，存储量表答题记录信息"}

    id: int = Field(default=None, primary_key=True, index=True)


"""量表答题详情中的题目（题目标题和类型相同则视为同一题，否则视为不同题）

Keyword arguments:
ScaleAnswerDetailQuesBase -- 量表答题详情中的题目基础模型
ScaleAnswerDetailQuesCreate -- 新增量表答题详情中的题目模型
ScaleAnswerDetailQuesUpdate -- 编辑量表答题详情中的题目模型
ScaleAnswerDetailQuesRead -- 量表答题详情中的题目读取模型
ScaleAnswerDetailQues -- 量表答题详情中的题目模型（表）
Return: return_description

"""


class ScaleAnswerOption(SQLModel):
    option_id: int = Field(nullable=False)  # 选项id
    input_content: str | None = Field(
        max_length=2000
    )  # 选项后的输入框内容 （如果为空则表示没有输入框）


class ScaleAnswerBlank(SQLModel):
    blank_id: int = Field(nullable=False)  # 空白id
    input_content: str | None = Field(
        max_length=2000
    )  # 空白后的输入框内容 （如果为空则表示没有输入框）


class ScaleAnswerMatrix(SQLModel):
    # 行id
    row_id: int
    # 维度名称
    classify: str | None = None
    # 列id
    col_id: int


class ScaleAnswer(SQLModel):
    answer: Union[List[ScaleAnswerOption], List[ScaleAnswerBlank],
                  List[ScaleAnswerMatrix], None] = None,


class ScaleAnswerDetailQuesBase(SQLModel):
    scale_answer_record_id: int = Field(
        nullable=False, foreign_key="scale_answer_record.id", ondelete="CASCADE"
    )  # 量表答题记录id
    title: str = Field(max_length=250, nullable=False)  # 题目内容
    hassubtitle: int = Field(default=0, nullable=False)  # 是否有子标题（0：否，1：是）
    subtitle: str | None = Field(max_length=5000)  # 子标题
    # 题目类型（1：单选题，2：多选题，3：单项填空，4：多项填空、5、矩阵单选、6、多维矩阵单选、7、基础量表）
    type: int = Field(nullable=False)
    order: str = Field(nullable=False, index=True, max_length=50)  # 答题顺序
    required: int = Field(default=0, nullable=False)  # 是否必答（0：否，1：是）


class ScaleAnswerDetailQuesCreate(ScaleAnswerDetailQuesBase):
    pass


class ScaleAnswerDetailQuesUpdate(ScaleAnswerDetailQuesBase):
    id: int


class ScaleAnswerDetailQuesRead(ScaleAnswerDetailQuesBase):
    id: int


class ScaleAnswerDetailQues(ScaleAnswerDetailQuesBase, table=True):
    __tablename__ = "scale_answer_detail_ques"
    __table_args__ = {"comment": "量表答题详情中的题目，存储量表答题详情中的题目信息"}

    id: int = Field(default=None, primary_key=True, index=True)

    options: List["ScaleAnswerDetailQuesOption"] | None = Relationship(
        back_populates="scale_answer_detail_ques"
    )  # 量表答题详情中的题目选项答案
    blanks: List["ScaleAnswerDetailQuesBlank"] | None = Relationship(
        back_populates="scale_answer_detail_ques"
    )  # 量表答题详情中的题目填空答案
    matrixs: List["ScaleAnswerDetailQuesMatrixSingleOptionRow"] | None = Relationship(
        back_populates="scale_answer_detail_ques"
    )  # 量表答题详情中的题目矩阵行答案



"""量表答题详情中的题目选项

Keyword arguments:
ScaleAnswerDetailQuesOptionBase -- 量表答题详情中的题目选项基础模型
ScaleAnswerDetailQuesOptionCreate -- 新增量表答题详情中的题目选项模型
ScaleAnswerDetailQuesOptionUpdate -- 编辑量表答题详情中的题目选项模型
ScaleAnswerDetailQuesOptionRead -- 量表答题详情中的题目选项读取模型
ScaleAnswerDetailQuesOption -- 量表答题详情中的题目选项模型（表）
Return: return_description

"""


class ScaleAnswerDetailQuesOptionBase(SQLModel):
    scale_answer_detail_ques_id: int = Field(
        nullable=False, foreign_key="scale_answer_detail_ques.id", ondelete="CASCADE"
    )  # 量表答题详情中的题目id
    parent_id: int | None = Field(
        default=None,
        nullable=True,
        foreign_key="scale_answer_detail_ques_option.id",
        ondelete="cASCADE",
    )  # 父选项id（如果是子选项，则需要填写父选项id）
    order: str = Field(nullable=False, index=True, max_length=50)  # 选项顺序
    content: str = Field(max_length=2000, nullable=False)  # 选项内容
    is_selected: int = Field(default=0, nullable=False)  # 是否选中（0：未选中，1：选中）
    # 选项后的输入框的类型，0：文本，1：数字，2：日期，3、手机号，4、日期，5、邮箱、6、地址、7、身高，8、体重,9、选择框)
    type: int | None = Field(nullable=True)
    placeholder: str | None = Field(max_length=500)  # 输入框的placeholder
    default_value: str | None = Field(max_length=500)  # 输入框的默认值
    required: bool = Field(nullable=False)  # 选项后的输入框内容是否必填
    input_content: str | None = Field(
        max_length=2000
    )  # 选项后的输入框内容 （如果为空则表示没有输入框）
    score: int | None = Field(nullable=True)  # 选项分数（如果分数为-1，则不计分）


class ScaleAnswerDetailQuesOptionCreate(ScaleAnswerDetailQuesOptionBase):
    pass


class ScaleAnswerDetailQuesOptionUpdate(ScaleAnswerDetailQuesOptionBase):
    id: int | None = Field(default=None, primary_key=True, index=True)


class ScaleAnswerDetailQuesOptionRead(ScaleAnswerDetailQuesOptionBase):
    id: int | None = Field(default=None, primary_key=True, index=True)


class ScaleAnswerDetailQuesOption(ScaleAnswerDetailQuesOptionBase, table=True):
    __tablename__ = "scale_answer_detail_ques_option"
    __table_args__ = {
        "comment": "量表答题详情中的题目选项，存储量表答题详情中的题目选项信息"
    }

    id: int = Field(default=None, primary_key=True, index=True)

    scale_answer_detail_ques: "ScaleAnswerDetailQues" = Relationship(
        back_populates="options"
    )  # 量表答题选项关联的题目

    __mapper_args__ = {
        "confirm_deleted_rows": False
    }


"""量表答题详情中的题目填空

Keyword arguments:
ScaleAnswerDetailQuesBlankBase -- 量表答题详情中的题目填空基础模型
ScaleAnswerDetailQuesBlankCreate -- 新增量表答题详情中的题目填空模型
ScaleAnswerDetailQuesBlankUpdate -- 编辑量表答题详情中的题目填空模型
ScaleAnswerDetailQuesBlankRead -- 量表答题详情中的题目填空读取模型
ScaleAnswerDetailQuesBlank -- 量表答题详情中的题目填空模型（表）
Return: return_description
"""


class ScaleAnswerDetailQuesBlankBase(SQLModel):
    scale_answer_detail_ques_id: int = Field(
        nullable=False,
        foreign_key="scale_answer_detail_ques.id",
        ondelete="CASCADE"
    )  # 量表答题详情中的题目id
    order: str = Field(nullable=False, index=True, max_length=50)  # 填空顺序
    # 填空题类型（0：文本，1：数字，2：日期，3、手机号，4、日期，5、邮箱、6、地址、7、身高，8、体重,9、选择框)
    type: int = Field(nullable=False)
    content: str = Field(max_length=500)  # 填空题内容
    score: int | None = Field(nullable=True)  # 填空题分数（如果分数为-1，则不计分）


class ScaleAnswerDetailQuesBlankCreate(ScaleAnswerDetailQuesBlankBase):
    pass


class ScaleAnswerDetailQuesBlankUpdate(ScaleAnswerDetailQuesBlankBase):
    id: int | None = Field(default=None, primary_key=True, index=True)


class ScaleAnswerDetailQuesBlankRead(ScaleAnswerDetailQuesBlankBase):
    id: int | None = Field(default=None, primary_key=True, index=True)


class ScaleAnswerDetailQuesBlank(ScaleAnswerDetailQuesBlankBase, table=True):
    __tablename__ = "scale_answer_detail_ques_blank"
    __table_args__ = {
        "comment": "量表答题详情中的题目填空，存储量表答题详情中的题目填空信息"
    }

    id: int = Field(default=None, primary_key=True, index=True)
    scale_answer_detail_ques: "ScaleAnswerDetailQues" = Relationship(
        back_populates="blanks"
    )  # 量表答题填空关联的题目


"""量表答题详情中的单/多维矩阵单选题行

Keyword arguments:
ScaleAnswerDetailQuesMatrixSingleOptionRowBase -- 量表答题详情中的单/多维矩阵单选题行基础模型
ScaleAnswerDetailQuesMatrixSingleOptionRowCreate -- 新增量表答题详情中的单/多维矩阵单选题行模型
ScaleAnswerDetailQuesMatrixSingleOptionRowUpdate -- 编辑量表答题详情中的单/多维矩阵单选题行模型
ScaleAnswerDetailQuesMatrixSingleOptionRowRead -- 量表答题详情中的单/多维矩阵单选题读取行模型
ScaleAnswerDetailQuesMatrixSingleOptionRow -- 量表答题详情中的单/多维矩阵单选题行模型（表）
Return: return_description
"""


class ScaleAnswerDetailQuesMatrixSingleOptionRowBase(SQLModel):
    scale_answer_detail_ques_id: int = Field(
        nullable=False,
        foreign_key="scale_answer_detail_ques.id",
        ondelete="CASCADE"
    )  # 量表答题详情中的题目id
    order: str = Field(nullable=False, index=True, max_length=50)  # 行顺序
    content: str = Field(max_length=500)


class ScaleAnswerDetailQuesMatrixSingleOptionRowCreate(ScaleAnswerDetailQuesMatrixSingleOptionRowBase):
    pass


class ScaleAnswerDetailQuesMatrixSingleOptionRowUpdate(ScaleAnswerDetailQuesMatrixSingleOptionRowBase):
    id: int | None = Field(default=None, primary_key=True, index=True)


class ScaleAnswerDetailQuesMatrixSingleOptionRowRead(ScaleAnswerDetailQuesMatrixSingleOptionRowBase):
    id: int | None = Field(default=None, primary_key=True, index=True)


class ScaleAnswerDetailQuesMatrixSingleOptionRowRead(ScaleAnswerDetailQuesMatrixSingleOptionRowBase):
    id: int | None = Field(default=None, primary_key=True, index=True)


class ScaleAnswerDetailQuesMatrixSingleOptionRow(ScaleAnswerDetailQuesMatrixSingleOptionRowBase, table=True):
    __tablename__ = "scale_answer_detail_ques_matrix_single_option_row"
    __table_args__ = {
        "comment": "量表答题详情中的单/多维矩阵单选题行，存储量表答题详情中的单/多维矩阵单选题行信息"
    }

    id: int = Field(default=None, primary_key=True, index=True)

    scale_answer_detail_ques: "ScaleAnswerDetailQues" = Relationship(
        back_populates="matrixs"
    )  # 量表答题单/多维矩阵单选题行关联的题目
    columns: List["ScaleAnswerDetailQuesMatrixSingleOptionColumn"] = Relationship(
        back_populates="row"
    )  # 量表答题单/多维矩阵单选题行关联的列


"""量表答题详情中的单/多维矩阵单选题列

Keyword arguments:
ScaleAnswerDetailQuesMatrixSingleOptionColumnBase -- 量表答题详情中的单/多维矩阵单选题列基础模型
ScaleAnswerDetailQuesMatrixSingleOptionColumnCreate -- 新增量表答题详情中的单/多维矩阵单选题列模型
ScaleAnswerDetailQuesMatrixSingleOptionColumnUpdate -- 编辑量表答题详情中的单/多维矩阵单选题列模型
ScaleAnswerDetailQuesMatrixSingleOptionColumnRead -- 量表答题详情中的单/多维矩阵单选题读取列模型
ScaleAnswerDetailQuesMatrixSingleOptionColumn -- 量表答题详情中的单/多维矩阵单选题列模型（表）
Return: return_description
"""


class ScaleAnswerDetailQuesMatrixSingleOptionColumnBase(SQLModel):
    row_id: int = Field(
        nullable=False,
        foreign_key="scale_answer_detail_ques_matrix_single_option_row.id",
        ondelete="CASCADE")  # 量表答题详情中的单/多维矩阵单选题行id
    order: str = Field(nullable=False, index=True, max_length=50)  # 列顺序
    classify: str | None = Field(max_length=2000)  # 列的分类（支持多维）
    content: str = Field(max_length=2000)  # 列内容
    is_selected: bool = Field(default=False)
    score: int | None = Field(nullable=True)  # 选项分数（如果分数为-1，则不计分）


class ScaleAnswerDetailQuesMatrixSingleOptionColumnCreate(ScaleAnswerDetailQuesMatrixSingleOptionColumnBase):
    pass


class ScaleAnswerDetailQuesMatrixSingleOptionColumnUpdate(ScaleAnswerDetailQuesMatrixSingleOptionColumnBase):
    id: int | None = Field(default=None, primary_key=True, index=True)


class ScaleAnswerDetailQuesMatrixSingleOptionColumnRead(ScaleAnswerDetailQuesMatrixSingleOptionColumnBase):
    id: int | None = Field(default=None, primary_key=True, index=True)


class ScaleAnswerDetailQuesMatrixSingleOptionColumn(ScaleAnswerDetailQuesMatrixSingleOptionColumnBase, table=True):
    __tablename__ = "scale_answer_detail_ques_matrix_single_option_column"  # 表名
    __table_args__ = {
        "comment": "量表答题详情中的单/多维矩阵单选题列，存储量表答题详情中的单/多维矩阵单选题列信息"
    }
    id: int | None = Field(default=None, primary_key=True, index=True)

    # scale_answer_detail_ques: "ScaleAnswerDetailQues" = Relationship(
    #     back_populates="columns"
    # )  # 量表答题单/ScaleAnswerDetailQues
    row: "ScaleAnswerDetailQuesMatrixSingleOptionRow" = Relationship(
        back_populates="columns"
    )  # 量表答题单/多维矩阵单选题列关联的行


"""量表表

Keyword arguments:
ScaleBase -- 量表基础模型
ScaleContent -- 量表查询参数
ScaleCreate -- 新增量表模型
ScaleUpdate -- 编辑量表模型
ScaleRead -- 量表读取模型
RespJsonScale -- 响应体模型
Scale -- 量表模型（表）
Return: return_description
"""


class ScaleBase(SQLModel):
    name: str = Field(max_length=50, nullable=False,
                      description="量表名称")  # 量表名称
    description: str = Field(max_length=255, description="量表描述")  # 量表描述
    is_push: int = Field(nullable=False, default=0,
                         description="是否可以推送，0：不可推送，1：可推送")  # 状态，0：不可推送，1：可推送


class ScaleCreate(ScaleBase):
    type: int = Field(nullable=False, default=1)  # 量表类型，1为基础量表，2为量表套餐


class ScaleUpdate(ScaleBase):
    pass


class ScaleRead(ScaleBase):
    id: int
    type: int = Field(nullable=False, default=1)  # 量表类型，1为基础量表，2为量表套餐
    org_id: int | None = Field(
        # 关联的机构id（org_id为空则为公共量表，否则为当前组织及其组织量表）
        nullable=True,
        foreign_key="system_org.id",
        ondelete="CASCADE",
    )
    org_name: str | None = Field(
        nullable=True, foreign_key="system_org.name", ondelete="SET NULL"
    )  # 所属组织机构名称
    create_id: int | None = Field(
        nullable=True, foreign_key="system_user.id", ondelete="SET NULL"
    )  # 创建人
    creator: str | None = Field(
        nullable=True, foreign_key="system_user.name", ondelete="SET NULL"
    )  # 创建人名称
    createtime: datetime = Field(default_factory=datetime.now)  # 创建时间
    update_id: int | None = Field(
        nullable=True, foreign_key="system_user.id", ondelete="SET NULL"
    )  # 更新人
    updater: str | None = Field(
        nullable=True, foreign_key="system_user.name", ondelete="SET NULL"
    )  # 更新人名称
    updatetime: datetime = Field(default_factory=datetime.now)  # 更新时间


class ScaleContent(SQLModel):
    total: int = Field(default=0)
    totalPages: int = Field(default=1)
    items: List[ScaleRead] = []


class RespJsonScale(SQLModel):
    code: int = Field(default=200)
    msg: str = Field(default="查询成功")
    data: ScaleContent | list = {}


class Scale(ScaleBase, table=True):
    __tablename__ = "scale"  # 表名
    __table_args__ = {"comment": "量表表，存储量表信息"}

    id: int | None = Field(default=None, primary_key=True, index=True)
    type: int = Field(nullable=False, default=1)  # 量表类型，1为基础量表，2为量表套餐
    is_deleted: bool = Field(nullable=False, default=0)  # 状态，0:正常，1:已删除
    org_id: int | None = Field(
        # 关联的机构id（org_id为空则为公共量表，否则为当前组织及其组织量表）
        nullable=True,
        foreign_key="system_org.id",
        ondelete="CASCADE",
    )
    create_id: int = Field(
        nullable=True, foreign_key="system_user.id", ondelete="SET NULL"
    )  # 创建人
    createtime: datetime = Field(default_factory=datetime.now)  # 创建时间
    update_id: int = Field(
        nullable=True, foreign_key="system_user.id", ondelete="SET NULL"
    )  # 更新人
    updatetime: datetime = Field(default_factory=datetime.now)  # 更新时间

    details_links: List["ScaleHistory"] = Relationship(
        back_populates="scale"
    )  # 量表详情列表（反向查询）

    def update(self):
        self.updatetime = datetime.now()

    def __str__(self):
        return "Scale(name:{})".format(self.name)


"""量表配置草稿表

Keyword arguments:
ScaleConfigDraftBase -- 量表配置草稿基础模型
ScaleConfigDraftContent -- 量表配置草稿查询参数
ScaleConfigDraftCreate -- 新增量表配置草稿模型
ScaleConfigDraftUpdate -- 编辑量表配置草稿模型
ScaleConfigDraftRead -- 量表配置草稿读取模型
RespJsonScaleConfigDraft -- 响应体模型
ScaleConfigDraft -- 量表配置草稿模型（表）

"""


class ScaleConfigDraftBase(SQLModel):
    draft: dict = Field(
        sa_column=Column(JSON, nullable=False, comment="量表配置草稿内容")
    )
    rules: dict | None = Field(
        sa_column=Column(JSON, nullable=True, comment="量表评分规则内容")
    )

class ScaleConfigDraftCreate(ScaleConfigDraftBase):
    pass

class ScaleConfigDraftUpdate(ScaleConfigDraftBase):
    id: int = Field(default=None, primary_key=True, index=True)

class ScaleConfigDraftRead(ScaleConfigDraftBase):
    id: int = Field(default=None, primary_key=True, index=True)
    scale_id: int = Field(
        nullable=False, foreign_key="scale.id", ondelete="CASCADE"
    )  # 关联的量表id
    create_id: int | None = Field(
        nullable=True, foreign_key="system_user.id", ondelete="SET NULL"
    )  # 创建人
    createtime: datetime = Field(default_factory=datetime.now)  # 创建时间


class RespJsonScaleConfigDraft(SQLModel):
    code: int = Field(default=200)
    msg: str = Field(default="查询成功")
    data: ScaleConfigDraftRead | None = {}


class ScaleConfigDraft(ScaleConfigDraftBase, table=True):
    __tablename__ = "scale_config_draft"  # 表名
    __table_args__ = {"comment": "量表配置草稿表，存储量表配置草稿信息"}

    id: int = Field(default=None, primary_key=True, index=True)
    scale_id: int = Field(
        nullable=False, foreign_key="scale.id", ondelete="CASCADE"
    )  # 关联的量表id
    create_id: int | None = Field(
        nullable=True, foreign_key="system_user.id", ondelete="SET NULL"
    )  # 创建人
    createtime: datetime = Field(default_factory=datetime.now)  # 创建时间

    def __str__(self):
        return "ScaleConfigDraft(id:{})".format(self.id)
